/*! JSON v3.3.2 | https://bestiejs.github.io/json3 | Copyright 2012-2015, Kit Cambridge, Benjamin Tan | http://kit.mit-license.org */
;(function () {
	// Detect the `define` function exposed by asynchronous module loaders. The
	// strict `define` check is necessary for compatibility with `r.js`.
	var isLoader = typeof define === "function" && define.amd;

	// A set of types used to distinguish objects from primitives.
	var objectTypes = {
		"function": true,
		"object": true
	};

	// Detect the `exports` object exposed by CommonJS implementations.
	var freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports;

	// Use the `global` object exposed by Node (including Browserify via
	// `insert-module-globals`), Narwhal, and Ringo as the default context,
	// and the `window` object in browsers. Rhino exports a `global` function
	// instead.
	var root = objectTypes[typeof window] && window || this,
		freeGlobal = freeExports && objectTypes[typeof module] && module && !module.nodeType && typeof global == "object" && global;

	if (freeGlobal && (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal || freeGlobal.self === freeGlobal)) {
		root = freeGlobal;
	}

	// Public: Initializes JSON 3 using the given `context` object, attaching the
	// `stringify` and `parse` functions to the specified `exports` object.
	function runInContext(context, exports) {
		context || (context = root.Object());
		exports || (exports = root.Object());

		// Native constructor aliases.
		var Number = context.Number || root.Number,
			String = context.String || root.String,
			Object = context.Object || root.Object,
			Date = context.Date || root.Date,
			SyntaxError = context.SyntaxError || root.SyntaxError,
			TypeError = context.TypeError || root.TypeError,
			Math = context.Math || root.Math,
			nativeJSON = context.JSON || root.JSON;

		// Delegate to the native `stringify` and `parse` implementations.
		if (typeof nativeJSON == "object" && nativeJSON) {
			exports.stringify = nativeJSON.stringify;
			exports.parse = nativeJSON.parse;
		}

		// Convenience aliases.
		var objectProto = Object.prototype,
			getClass = objectProto.toString,
			isProperty = objectProto.hasOwnProperty,
			undefined;

		// Internal: Contains `try...catch` logic used by other functions.
		// This prevents other functions from being deoptimized.
		function attempt(func, errorFunc) {
			try {
				func();
			} catch (exception) {
				if (errorFunc) {
					errorFunc();
				}
			}
		}

		// Test the `Date#getUTC*` methods. Based on work by @Yaffle.
		var isExtended = new Date(-3509827334573292);
		attempt(function () {
			// The `getUTCFullYear`, `Month`, and `Date` methods return nonsensical
			// results for certain dates in Opera >= 10.53.
			isExtended = isExtended.getUTCFullYear() == -109252 && isExtended.getUTCMonth() === 0 && isExtended.getUTCDate() === 1 &&
				isExtended.getUTCHours() == 10 && isExtended.getUTCMinutes() == 37 && isExtended.getUTCSeconds() == 6 && isExtended.getUTCMilliseconds() == 708;
		});

		// Internal: Determines whether the native `JSON.stringify` and `parse`
		// implementations are spec-compliant. Based on work by Ken Snyder.
		function has(name) {
			if (has[name] != null) {
				// Return cached feature test result.
				return has[name];
			}
			var isSupported;
			if (name == "bug-string-char-index") {
				// IE <= 7 doesn't support accessing string characters using square
				// bracket notation. IE 8 only supports this for primitives.
				isSupported = "a"[0] != "a";
			} else if (name == "json") {
				// Indicates whether both `JSON.stringify` and `JSON.parse` are
				// supported.
				isSupported = has("json-stringify") && has("date-serialization") && has("json-parse");
			} else if (name == "date-serialization") {
				// Indicates whether `Date`s can be serialized accurately by `JSON.stringify`.
				isSupported = has("json-stringify") && isExtended;
				if (isSupported) {
					var stringify = exports.stringify;
					attempt(function () {
						isSupported =
							// JSON 2, Prototype <= 1.7, and older WebKit builds incorrectly
							// serialize extended years.
							stringify(new Date(-8.64e15)) == '"-271821-04-20T00:00:00.000Z"' &&
							// The milliseconds are optional in ES 5, but required in 5.1.
							stringify(new Date(8.64e15)) == '"+275760-09-13T00:00:00.000Z"' &&
							// Firefox <= 11.0 incorrectly serializes years prior to 0 as negative
							// four-digit years instead of six-digit years. Credits: @Yaffle.
							stringify(new Date(-621987552e5)) == '"-000001-01-01T00:00:00.000Z"' &&
							// Safari <= 5.1.5 and Opera >= 10.53 incorrectly serialize millisecond
							// values less than 1000. Credits: @Yaffle.
							stringify(new Date(-1)) == '"1969-12-31T23:59:59.999Z"';
					});
				}
			} else {
				var value, serialized = '{"a":[1,true,false,null,"\\u0000\\b\\n\\f\\r\\t"]}';
				// Test `JSON.stringify`.
				if (name == "json-stringify") {
					var stringify = exports.stringify, stringifySupported = typeof stringify == "function";
					if (stringifySupported) {
						// A test function object with a custom `toJSON` method.
						(value = function () {
							return 1;
						}).toJSON = value;
						attempt(function () {
							stringifySupported =
								// Firefox 3.1b1 and b2 serialize string, number, and boolean
								// primitives as object literals.
								stringify(0) === "0" &&
								// FF 3.1b1, b2, and JSON 2 serialize wrapped primitives as object
								// literals.
								stringify(new Number()) === "0" &&
								stringify(new String()) == '""' &&
								// FF 3.1b1, 2 throw an error if the value is `null`, `undefined`, or
								// does not define a canonical JSON representation (this applies to
								// objects with `toJSON` properties as well, *unless* they are nested
								// within an object or array).
								stringify(getClass) === undefined &&
								// IE 8 serializes `undefined` as `"undefined"`. Safari <= 5.1.7 and
								// FF 3.1b3 pass this test.
								stringify(undefined) === undefined &&
								// Safari <= 5.1.7 and FF 3.1b3 throw `Error`s and `TypeError`s,
								// respectively, if the value is omitted entirely.
								stringify() === undefined &&
								// FF 3.1b1, 2 throw an error if the given value is not a number,
								// string, array, object, Boolean, or `null` literal. This applies to
								// objects with custom `toJSON` methods as well, unless they are nested
								// inside object or array literals. YUI 3.0.0b1 ignores custom `toJSON`
								// methods entirely.
								stringify(value) === "1" &&
								stringify([value]) == "[1]" &&
								// Prototype <= 1.6.1 serializes `[undefined]` as `"[]"` instead of
								// `"[null]"`.
								stringify([undefined]) == "[null]" &&
								// YUI 3.0.0b1 fails to serialize `null` literals.
								stringify(null) == "null" &&
								// FF 3.1b1, 2 halts serialization if an array contains a function:
								// `[1, true, getClass, 1]` serializes as "[1,true,],". FF 3.1b3
								// elides non-JSON values from objects and arrays, unless they
								// define custom `toJSON` methods.
								stringify([undefined, getClass, null]) == "[null,null,null]" &&
								// Simple serialization test. FF 3.1b1 uses Unicode escape sequences
								// where character escape codes are expected (e.g., `\b` => `\u0008`).
								stringify({ "a": [value, true, false, null, "\x00\b\n\f\r\t"] }) == serialized &&
								// FF 3.1b1 and b2 ignore the `filter` and `width` arguments.
								stringify(null, value) === "1" &&
								stringify([1, 2], null, 1) == "[\n 1,\n 2\n]";
						}, function () {
							stringifySupported = false;
						});
					}
					isSupported = stringifySupported;
				}
				// Test `JSON.parse`.
				if (name == "json-parse") {
					var parse = exports.parse, parseSupported;
					if (typeof parse == "function") {
						attempt(function () {
							// FF 3.1b1, b2 will throw an exception if a bare literal is provided.
							// Conforming implementations should also coerce the initial argument to
							// a string prior to parsing.
							if (parse("0") === 0 && !parse(false)) {
								// Simple parsing test.
								value = parse(serialized);
								parseSupported = value["a"].length == 5 && value["a"][0] === 1;
								if (parseSupported) {
									attempt(function () {
										// Safari <= 5.1.2 and FF 3.1b1 allow unescaped tabs in strings.
										parseSupported = !parse('"\t"');
									});
									if (parseSupported) {
										attempt(function () {
											// FF 4.0 and 4.0.1 allow leading `+` signs and leading
											// decimal points. FF 4.0, 4.0.1, and IE 9-10 also allow
											// certain octal literals.
											parseSupported = parse("01") !== 1;
										});
									}
									if (parseSupported) {
										attempt(function () {
											// FF 4.0, 4.0.1, and Rhino 1.7R3-R4 allow trailing decimal
											// points. These environments, along with FF 3.1b1 and 2,
											// also allow trailing commas in JSON objects and arrays.
											parseSupported = parse("1.") !== 1;
										});
									}
								}
							}
						}, function () {
							parseSupported = false;
						});
					}
					isSupported = parseSupported;
				}
			}
			return has[name] = !!isSupported;
		}
		has["bug-string-char-index"] = has["date-serialization"] = has["json"] = has["json-stringify"] = has["json-parse"] = null;

		if (!has("json")) {
			// Common `[[Class]]` name aliases.
			var functionClass = "[object Function]",
				dateClass = "[object Date]",
				numberClass = "[object Number]",
				stringClass = "[object String]",
				arrayClass = "[object Array]",
				booleanClass = "[object Boolean]";

			// Detect incomplete support for accessing string characters by index.
			var charIndexBuggy = has("bug-string-char-index");

			// Internal: Normalizes the `for...in` iteration algorithm across
			// environments. Each enumerated key is yielded to a `callback` function.
			var forOwn = function (object, callback) {
				var size = 0, Properties, members, property;

				// Tests for bugs in the current environment's `for...in` algorithm. The
				// `valueOf` property inherits the non-enumerable flag from
				// `Object.prototype` in older versions of IE, Netscape, and Mozilla.
				(Properties = function () {
					this.valueOf = 0;
				}).prototype.valueOf = 0;

				// Iterate over a new instance of the `Properties` class.
				members = new Properties();
				for (property in members) {
					// Ignore all properties inherited from `Object.prototype`.
					if (isProperty.call(members, property)) {
						size++;
					}
				}
				Properties = members = null;

				// Normalize the iteration algorithm.
				if (!size) {
					// A list of non-enumerable properties inherited from `Object.prototype`.
					members = ["valueOf", "toString", "toLocaleString", "propertyIsEnumerable", "isPrototypeOf", "hasOwnProperty", "constructor"];
					// IE <= 8, Mozilla 1.0, and Netscape 6.2 ignore shadowed non-enumerable
					// properties.
					forOwn = function (object, callback) {
						var isFunction = getClass.call(object) == functionClass, property, length;
						var hasProperty = !isFunction && typeof object.constructor != "function" && objectTypes[typeof object.hasOwnProperty] && object.hasOwnProperty || isProperty;
						for (property in object) {
							// Gecko <= 1.0 enumerates the `prototype` property of functions under
							// certain conditions; IE does not.
							if (!(isFunction && property == "prototype") && hasProperty.call(object, property)) {
								callback(property);
							}
						}
						// Manually invoke the callback for each non-enumerable property.
						for (length = dontEnums.length; property = dontEnums[--length];) {
							if (hasProperty.call(object, property)) {
								callback(property);
							}
						}
					};
				} else {
					// No bugs detected; use the standard `for...in` algorithm.
					forOwn = function (object, callback) {
						var isFunction = getClass.call(object) == functionClass, property, isConstructor;
						for (property in object) {
							if (!(isFunction && property == "prototype") && isProperty.call(object, property) && !(isConstructor = property === "constructor")) {
								callback(property);
							}
						}
						// Manually invoke the callback for the `constructor` property due to
						// cross-environment inconsistencies.
						if (isConstructor || isProperty.call(object, (property = "constructor"))) {
							callback(property);
						}
					};
				}
				return forOwn(object, callback);
			};

			// Public: Serializes a JavaScript `value` as a JSON string. The optional
			// `filter` argument may specify either a function that alters how object and
			// array members are serialized, or an array of strings and numbers that
			// indicates which properties should be serialized. The optional `width`
			// argument may be either a string or number that specifies the indentation
			// level of the output.
			if (!has("json-stringify") && !has("date-serialization")) {
				// Internal: A map of control characters and their escaped equivalents.
				var Escapes = {
					92: "\\\\",
					34: '\\"',
					8: "\\b",
					12: "\\f",
					10: "\\n",
					13: "\\r",
					9: "\\t"
				};

				// Internal: Converts `value` into a zero-padded string such that its
				// length is at least equal to `width`. The `width` must be <= 6.
				var leadingZeroes = "000000";
				var toPaddedString = function (width, value) {
					// The `|| 0` expression is necessary to work around a bug in
					// Opera <= 7.54u2 where `0 == -0`, but `String(-0) !== "0"`.
					return (leadingZeroes + (value || 0)).slice(-width);
				};

				// Internal: Serializes a date object.
				var serializeDate = function (value) {
					var getData, year, month, date, time, hours, minutes, seconds, milliseconds;
					// Define additional utility methods if the `Date` methods are buggy.
					if (!isExtended) {
						var floor = Math.floor;
						// A mapping between the months of the year and the number of days between
						// January 1st and the first of the respective month.
						var Months = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];
						// Internal: Calculates the number of days between the Unix epoch and the
						// first day of the given month.
						var getDay = function (year, month) {
							return Months[month] + 365 * (year - 1970) + floor((year - 1969 + (month = +(month > 1))) / 4) - floor((year - 1901 + month) / 100) + floor((year - 1601 + month) / 400);
						};
						getData = function (value) {
							// Manually compute the year, month, date, hours, minutes,
							// seconds, and milliseconds if the `getUTC*` methods are
							// buggy. Adapted from @Yaffle's `date-shim` project.
							date = floor(value / 864e5);
							for (year = floor(date / 365.2425) + 1970 - 1; getDay(year + 1, 0) <= date; year++);
							for (month = floor((date - getDay(year, 0)) / 30.42); getDay(year, month + 1) <= date; month++);
							date = 1 + date - getDay(year, month);
							// The `time` value specifies the time within the day (see ES
							// 5.1 section 15.9.1.2). The formula `(A % B + B) % B` is used
							// to compute `A modulo B`, as the `%` operator does not
							// correspond to the `modulo` operation for negative numbers.
							time = (value % 864e5 + 864e5) % 864e5;
							// The hours, minutes, seconds, and milliseconds are obtained by
							// decomposing the time within the day. See section 15.9.1.10.
							hours = floor(time / 36e5) % 24;
							minutes = floor(time / 6e4) % 60;
							seconds = floor(time / 1e3) % 60;
							milliseconds = time % 1e3;
						};
					} else {
						getData = function (value) {
							year = value.getUTCFullYear();
							month = value.getUTCMonth();
							date = value.getUTCDate();
							hours = value.getUTCHours();
							minutes = value.getUTCMinutes();
							seconds = value.getUTCSeconds();
							milliseconds = value.getUTCMilliseconds();
						};
					}
					serializeDate = function (value) {
						if (value > -1 / 0 && value < 1 / 0) {
							// Dates are serialized according to the `Date#toJSON` method
							// specified in ES 5.1 section 15.9.5.44. See section 15.9.1.15
							// for the ISO 8601 date time string format.
							getData(value);
							// Serialize extended years correctly.
							value = (year <= 0 || year >= 1e4 ? (year < 0 ? "-" : "+") + toPaddedString(6, year < 0 ? -year : year) : toPaddedString(4, year)) +
								"-" + toPaddedString(2, month + 1) + "-" + toPaddedString(2, date) +
								// Months, dates, hours, minutes, and seconds should have two
								// digits; milliseconds should have three.
								"T" + toPaddedString(2, hours) + ":" + toPaddedString(2, minutes) + ":" + toPaddedString(2, seconds) +
								// Milliseconds are optional in ES 5.0, but required in 5.1.
								"." + toPaddedString(3, milliseconds) + "Z";
							year = month = date = hours = minutes = seconds = milliseconds = null;
						} else {
							value = null;
						}
						return value;
					};
					return serializeDate(value);
				};

				// For environments with `JSON.stringify` but buggy date serialization,
				// we override the native `Date#toJSON` implementation with a
				// spec-compliant one.
				if (has("json-stringify") && !has("date-serialization")) {
					// Internal: the `Date#toJSON` implementation used to override the native one.
					function dateToJSON (key) {
						return serializeDate(this);
					}

					// Public: `JSON.stringify`. See ES 5.1 section 15.12.3.
					var nativeStringify = exports.stringify;
					exports.stringify = function (source, filter, width) {
						var nativeToJSON = Date.prototype.toJSON;
						Date.prototype.toJSON = dateToJSON;
						var result = nativeStringify(source, filter, width);
						Date.prototype.toJSON = nativeToJSON;
						return result;
					}
				} else {
					// Internal: Double-quotes a string `value`, replacing all ASCII control
					// characters (characters with code unit values between 0 and 31) with
					// their escaped equivalents. This is an implementation of the
					// `Quote(value)` operation defined in ES 5.1 section 15.12.3.
					var unicodePrefix = "\\u00";
					var escapeChar = function (character) {
						var charCode = character.charCodeAt(0), escaped = Escapes[charCode];
						if (escaped) {
							return escaped;
						}
						return unicodePrefix + toPaddedString(2, charCode.toString(16));
					};
					var reEscape = /[\x00-\x1f\x22\x5c]/g;
					var quote = function (value) {
						reEscape.lastIndex = 0;
						return '"' +
							(
								reEscape.test(value)
									? value.replace(reEscape, escapeChar)
									: value
							) +
							'"';
					};

					// Internal: Recursively serializes an object. Implements the
					// `Str(key, holder)`, `JO(value)`, and `JA(value)` operations.
					var serialize = function (property, object, callback, properties, whitespace, indentation, stack) {
						var value, type, className, results, element, index, length, prefix, result;
						attempt(function () {
							// Necessary for host object support.
							value = object[property];
						});
						if (typeof value == "object" && value) {
							if (value.getUTCFullYear && getClass.call(value) == dateClass && value.toJSON === Date.prototype.toJSON) {
								value = serializeDate(value);
							} else if (typeof value.toJSON == "function") {
								value = value.toJSON(property);
							}
						}
						if (callback) {
							// If a replacement function was provided, call it to obtain the value
							// for serialization.
							value = callback.call(object, property, value);
						}
						// Exit early if value is `undefined` or `null`.
						if (value == undefined) {
							return value === undefined ? value : "null";
						}
						type = typeof value;
						// Only call `getClass` if the value is an object.
						if (type == "object") {
							className = getClass.call(value);
						}
						switch (className || type) {
							case "boolean":
							case booleanClass:
								// Booleans are represented literally.
								return "" + value;
							case "number":
							case numberClass:
								// JSON numbers must be finite. `Infinity` and `NaN` are serialized as
								// `"null"`.
								return value > -1 / 0 && value < 1 / 0 ? "" + value : "null";
							case "string":
							case stringClass:
								// Strings are double-quoted and escaped.
								return quote("" + value);
						}
						// Recursively serialize objects and arrays.
						if (typeof value == "object") {
							// Check for cyclic structures. This is a linear search; performance
							// is inversely proportional to the number of unique nested objects.
							for (length = stack.length; length--;) {
								if (stack[length] === value) {
									// Cyclic structures cannot be serialized by `JSON.stringify`.
									throw TypeError();
								}
							}
							// Add the object to the stack of traversed objects.
							stack.push(value);
							results = [];
							// Save the current indentation level and indent one additional level.
							prefix = indentation;
							indentation += whitespace;
							if (className == arrayClass) {
								// Recursively serialize array elements.
								for (index = 0, length = value.length; index < length; index++) {
									element = serialize(index, value, callback, properties, whitespace, indentation, stack);
									results.push(element === undefined ? "null" : element);
								}
								result = results.length ? (whitespace ? "[\n" + indentation + results.join(",\n" + indentation) + "\n" + prefix + "]" : ("[" + results.join(",") + "]")) : "[]";
							} else {
								// Recursively serialize object members. Members are selected from
								// either a user-specified list of property names, or the object
								// itself.
								forOwn(properties || value, function (property) {
									var element = serialize(property, value, callback, properties, whitespace, indentation, stack);
									if (element !== undefined) {
										// According to ES 5.1 section 15.12.3: "If `gap` {whitespace}
										// is not the empty string, let `member` {quote(property) + ":"}
										// be the concatenation of `member` and the `space` character."
										// The "`space` character" refers to the literal space
										// character, not the `space` {width} argument provided to
										// `JSON.stringify`.
										results.push(quote(property) + ":" + (whitespace ? " " : "") + element);
									}
								});
								result = results.length ? (whitespace ? "{\n" + indentation + results.join(",\n" + indentation) + "\n" + prefix + "}" : ("{" + results.join(",") + "}")) : "{}";
							}
							// Remove the object from the traversed object stack.
							stack.pop();
							return result;
						}
					};

					// Public: `JSON.stringify`. See ES 5.1 section 15.12.3.
					exports.stringify = function (source, filter, width) {
						var whitespace, callback, properties, className;
						if (objectTypes[typeof filter] && filter) {
							className = getClass.call(filter);
							if (className == functionClass) {
								callback = filter;
							} else if (className == arrayClass) {
								// Convert the property names array into a makeshift set.
								properties = {};
								for (var index = 0, length = filter.length, value; index < length;) {
									value = filter[index++];
									className = getClass.call(value);
									if (className == "[object String]" || className == "[object Number]") {
										properties[value] = 1;
									}
								}
							}
						}
						if (width) {
							className = getClass.call(width);
							if (className == numberClass) {
								// Convert the `width` to an integer and create a string containing
								// `width` number of space characters.
								if ((width -= width % 1) > 0) {
									if (width > 10) {
										width = 10;
									}
									for (whitespace = ""; whitespace.length < width;) {
										whitespace += " ";
									}
								}
							} else if (className == stringClass) {
								whitespace = width.length <= 10 ? width : width.slice(0, 10);
							}
						}
						// Opera <= 7.54u2 discards the values associated with empty string keys
						// (`""`) only if they are used directly within an object member list
						// (e.g., `!("" in { "": 1})`).
						return serialize("", (value = {}, value[""] = source, value), callback, properties, whitespace, "", []);
					};
				}
			}

			// Public: Parses a JSON source string.
			if (!has("json-parse")) {
				var fromCharCode = String.fromCharCode;

				// Internal: A map of escaped control characters and their unescaped
				// equivalents.
				var Unescapes = {
					92: "\\",
					34: '"',
					47: "/",
					98: "\b",
					116: "\t",
					110: "\n",
					102: "\f",
					114: "\r"
				};

				// Internal: Stores the parser state.
				var Index, Source;

				// Internal: Resets the parser state and throws a `SyntaxError`.
				var abort = function () {
					Index = Source = null;
					throw SyntaxError();
				};

				// Internal: Returns the next token, or `"$"` if the parser has reached
				// the end of the source string. A token may be a string, number, `null`
				// literal, or Boolean literal.
				var lex = function () {
					var source = Source, length = source.length, value, begin, position, isSigned, charCode;
					while (Index < length) {
						charCode = source.charCodeAt(Index);
						switch (charCode) {
							case 9: case 10: case 13: case 32:
							// Skip whitespace tokens, including tabs, carriage returns, line
							// feeds, and space characters.
							Index++;
							break;
							case 123: case 125: case 91: case 93: case 58: case 44:
							// Parse a punctuator token (`{`, `}`, `[`, `]`, `:`, or `,`) at
							// the current position.
							value = charIndexBuggy ? source.charAt(Index) : source[Index];
							Index++;
							return value;
							case 34:
								// `"` delimits a JSON string; advance to the next character and
								// begin parsing the string. String tokens are prefixed with the
								// sentinel `@` character to distinguish them from punctuators and
								// end-of-string tokens.
								for (value = "@", Index++; Index < length;) {
									charCode = source.charCodeAt(Index);
									if (charCode < 32) {
										// Unescaped ASCII control characters (those with a code unit
										// less than the space character) are not permitted.
										abort();
									} else if (charCode == 92) {
										// A reverse solidus (`\`) marks the beginning of an escaped
										// control character (including `"`, `\`, and `/`) or Unicode
										// escape sequence.
										charCode = source.charCodeAt(++Index);
										switch (charCode) {
											case 92: case 34: case 47: case 98: case 116: case 110: case 102: case 114:
											// Revive escaped control characters.
											value += Unescapes[charCode];
											Index++;
											break;
											case 117:
												// `\u` marks the beginning of a Unicode escape sequence.
												// Advance to the first character and validate the
												// four-digit code point.
												begin = ++Index;
												for (position = Index + 4; Index < position; Index++) {
													charCode = source.charCodeAt(Index);
													// A valid sequence comprises four hexdigits (case-
													// insensitive) that form a single hexadecimal value.
													if (!(charCode >= 48 && charCode <= 57 || charCode >= 97 && charCode <= 102 || charCode >= 65 && charCode <= 70)) {
														// Invalid Unicode escape sequence.
														abort();
													}
												}
												// Revive the escaped character.
												value += fromCharCode("0x" + source.slice(begin, Index));
												break;
											default:
												// Invalid escape sequence.
												abort();
										}
									} else {
										if (charCode == 34) {
											// An unescaped double-quote character marks the end of the
											// string.
											break;
										}
										charCode = source.charCodeAt(Index);
										begin = Index;
										// Optimize for the common case where a string is valid.
										while (charCode >= 32 && charCode != 92 && charCode != 34) {
											charCode = source.charCodeAt(++Index);
										}
										// Append the string as-is.
										value += source.slice(begin, Index);
									}
								}
								if (source.charCodeAt(Index) == 34) {
									// Advance to the next character and return the revived string.
									Index++;
									return value;
								}
								// Unterminated string.
								abort();
							default:
								// Parse numbers and literals.
								begin = Index;
								// Advance past the negative sign, if one is specified.
								if (charCode == 45) {
									isSigned = true;
									charCode = source.charCodeAt(++Index);
								}
								// Parse an integer or floating-point value.
								if (charCode >= 48 && charCode <= 57) {
									// Leading zeroes are interpreted as octal literals.
									if (charCode == 48 && ((charCode = source.charCodeAt(Index + 1)), charCode >= 48 && charCode <= 57)) {
										// Illegal octal literal.
										abort();
									}
									isSigned = false;
									// Parse the integer component.
									for (; Index < length && ((charCode = source.charCodeAt(Index)), charCode >= 48 && charCode <= 57); Index++);
									// Floats cannot contain a leading decimal point; however, this
									// case is already accounted for by the parser.
									if (source.charCodeAt(Index) == 46) {
										position = ++Index;
										// Parse the decimal component.
										for (; position < length; position++) {
											charCode = source.charCodeAt(position);
											if (charCode < 48 || charCode > 57) {
												break;
											}
										}
										if (position == Index) {
											// Illegal trailing decimal.
											abort();
										}
										Index = position;
									}
									// Parse exponents. The `e` denoting the exponent is
									// case-insensitive.
									charCode = source.charCodeAt(Index);
									if (charCode == 101 || charCode == 69) {
										charCode = source.charCodeAt(++Index);
										// Skip past the sign following the exponent, if one is
										// specified.
										if (charCode == 43 || charCode == 45) {
											Index++;
										}
										// Parse the exponential component.
										for (position = Index; position < length; position++) {
											charCode = source.charCodeAt(position);
											if (charCode < 48 || charCode > 57) {
												break;
											}
										}
										if (position == Index) {
											// Illegal empty exponent.
											abort();
										}
										Index = position;
									}
									// Coerce the parsed value to a JavaScript number.
									return +source.slice(begin, Index);
								}
								// A negative sign may only precede numbers.
								if (isSigned) {
									abort();
								}
								// `true`, `false`, and `null` literals.
								var temp = source.slice(Index, Index + 4);
								if (temp == "true") {
									Index += 4;
									return true;
								} else if (temp == "fals" && source.charCodeAt(Index + 4 ) == 101) {
									Index += 5;
									return false;
								} else if (temp == "null") {
									Index += 4;
									return null;
								}
								// Unrecognized token.
								abort();
						}
					}
					// Return the sentinel `$` character if the parser has reached the end
					// of the source string.
					return "$";
				};

				// Internal: Parses a JSON `value` token.
				var get = function (value) {
					var results, hasMembers;
					if (value == "$") {
						// Unexpected end of input.
						abort();
					}
					if (typeof value == "string") {
						if ((charIndexBuggy ? value.charAt(0) : value[0]) == "@") {
							// Remove the sentinel `@` character.
							return value.slice(1);
						}
						// Parse object and array literals.
						if (value == "[") {
							// Parses a JSON array, returning a new JavaScript array.
							results = [];
							for (;;) {
								value = lex();
								// A closing square bracket marks the end of the array literal.
								if (value == "]") {
									break;
								}
								// If the array literal contains elements, the current token
								// should be a comma separating the previous element from the
								// next.
								if (hasMembers) {
									if (value == ",") {
										value = lex();
										if (value == "]") {
											// Unexpected trailing `,` in array literal.
											abort();
										}
									} else {
										// A `,` must separate each array element.
										abort();
									}
								} else {
									hasMembers = true;
								}
								// Elisions and leading commas are not permitted.
								if (value == ",") {
									abort();
								}
								results.push(get(value));
							}
							return results;
						} else if (value == "{") {
							// Parses a JSON object, returning a new JavaScript object.
							results = {};
							for (;;) {
								value = lex();
								// A closing curly brace marks the end of the object literal.
								if (value == "}") {
									break;
								}
								// If the object literal contains members, the current token
								// should be a comma separator.
								if (hasMembers) {
									if (value == ",") {
										value = lex();
										if (value == "}") {
											// Unexpected trailing `,` in object literal.
											abort();
										}
									} else {
										// A `,` must separate each object member.
										abort();
									}
								} else {
									hasMembers = true;
								}
								// Leading commas are not permitted, object property names must be
								// double-quoted strings, and a `:` must separate each property
								// name and value.
								if (value == "," || typeof value != "string" || (charIndexBuggy ? value.charAt(0) : value[0]) != "@" || lex() != ":") {
									abort();
								}
								results[value.slice(1)] = get(lex());
							}
							return results;
						}
						// Unexpected token encountered.
						abort();
					}
					return value;
				};

				// Internal: Updates a traversed object member.
				var update = function (source, property, callback) {
					var element = walk(source, property, callback);
					if (element === undefined) {
						delete source[property];
					} else {
						source[property] = element;
					}
				};

				// Internal: Recursively traverses a parsed JSON object, invoking the
				// `callback` function for each value. This is an implementation of the
				// `Walk(holder, name)` operation defined in ES 5.1 section 15.12.2.
				var walk = function (source, property, callback) {
					var value = source[property], length;
					if (typeof value == "object" && value) {
						// `forOwn` can't be used to traverse an array in Opera <= 8.54
						// because its `Object#hasOwnProperty` implementation returns `false`
						// for array indices (e.g., `![1, 2, 3].hasOwnProperty("0")`).
						if (getClass.call(value) == arrayClass) {
							for (length = value.length; length--;) {
								update(getClass, forOwn, value, length, callback);
							}
						} else {
							forOwn(value, function (property) {
								update(value, property, callback);
							});
						}
					}
					return callback.call(source, property, value);
				};

				// Public: `JSON.parse`. See ES 5.1 section 15.12.2.
				exports.parse = function (source, callback) {
					var result, value;
					Index = 0;
					Source = "" + source;
					result = get(lex());
					// If a JSON string contains multiple tokens, it is invalid.
					if (lex() != "$") {
						abort();
					}
					// Reset the parser state.
					Index = Source = null;
					return callback && getClass.call(callback) == functionClass ? walk((value = {}, value[""] = result, value), "", callback) : result;
				};
			}
		}

		exports.runInContext = runInContext;
		return exports;
	}

	if (freeExports && !isLoader) {
		// Export for CommonJS environments.
		runInContext(root, freeExports);
	} else {
		// Export for web browsers and JavaScript engines.
		var nativeJSON = root.JSON,
			previousJSON = root.JSON3,
			isRestored = false;

		var JSON3 = runInContext(root, (root.JSON3 = {
			// Public: Restores the original value of the global `JSON` object and
			// returns a reference to the `JSON3` object.
			"noConflict": function () {
				if (!isRestored) {
					isRestored = true;
					root.JSON = nativeJSON;
					root.JSON3 = previousJSON;
					nativeJSON = previousJSON = null;
				}
				return JSON3;
			}
		}));

		root.JSON = {
			"parse": JSON3.parse,
			"stringify": JSON3.stringify
		};
	}

	// Export for asynchronous module loaders.
	if (isLoader) {
		define(function () {
			return JSON3;
		});
	}
}).call(this);
